package com.bawei.newsapplication.view.activity.lotterys
import android.animation.ValueAnimator
import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.Paint
import android.util.AttributeSet
import android.util.Log
import android.view.MotionEvent
import android.view.View
import android.view.animation.LinearInterpolator
import com.bawei.newsapplication.R
import kotlin.math.pow
import kotlin.math.sqrt

/**
 * 作者: 谢庆平
 * 时间: 2024/10/18 11:57
 * 描述:抽奖界面
以下是对热点新闻所包含的 “首页”“热点视频”“全民拍”“问答”“我的（登录和微信登录）” 各板块的介绍：
 * 首页：
 * 内容呈现：这是热点新闻平台的门面和核心展示区域。通常会将最重要、最热门、
 * 最具时效性的新闻资讯以多种形式呈现出来，比如头条新闻会以大标题、醒目的图片等方式突出展示，
 * 方便用户第一时间获取关键信息。新闻的来源广泛，包括专业的新闻媒体机构、记者采写的报道，
 * 以及一些经过筛选的自媒体或其他渠道的优质内容。
 * 功能特点：具备综合性和导航性。一方面，它整合了各种类型的热点新闻，如政治、经济、社会、文化、科技、体育等领域
 * 的重大事件和突发新闻，满足不同用户的信息需求；另一方面，首页还会设置分类导航、热门话题标签等，
 * 方便用户快速找到自己感兴趣的新闻类别或特定主题的新闻报道。
 * 热点视频：
 * 内容来源：该板块主要汇聚了与热点新闻相关的视频内容。
 * 这些视频的来源包括新闻媒体机构制作的新闻视频报道、现场目击者拍摄的视频素材、
 * 专业视频创作者根据热点新闻事件创作的解读或评论视频等。比如一些重大事件的现场视频、
 * 新闻发布会的视频记录、专家对热点事件的分析视频等。
 * 呈现形式：以视频的形式生动、直观地展现新闻内容，
 * 相比文字和图片更具感染力和冲击力。视频的时长不一，既有简短的新闻快讯视频，
 * 也有较为深入的专题视频报道。用户可以通过播放、暂停、快进、快退等操作来观看视频，
 * 还可以在视频下方查看相关的文字介绍、评论和点赞等信息。
 * 全民拍：
 * 平台性质：是一个鼓励广大民众参与新闻素材提供和新闻事件分享的互动平台。普通民众可以使用手机或其他摄影设备，拍摄身边发生的新闻事件、社会现象、有趣的场景等，并通过该平台上传分享。
 * 作用意义：一方面，它为新闻媒体提供了丰富的新闻素材来源，拓宽了新闻的采集渠道，使新闻更加贴近生活、贴近群众；另一方面，也为民众提供了一个表达自己观点、参与新闻传播的机会，增强了民众的新闻参与感和社会责任感。
 * 问答：
 * 问题类型：这里集中了用户关于热点新闻的各种疑问和探讨。
 * 问题可能涉及对新闻事件的背景、原因、影响的询问，对新闻中涉及的专业知识或法律问题的求解，
 * 对不同观点的争论等。例如，对于一些复杂的国际局势热点新闻，用户可能会问
 * “某地区冲突的根源是什么”“该事件对全球经济会产生怎样的影响” 等问题。
 * 互动模式：用户可以提出问题，也可以回答其他用户的问题。
 * 这种互动模式促进了用户之间的交流和思想碰撞，有助于更深入地理解热点新闻事件。
 * 同时，一些专业的新闻工作者、专家学者或相关领域的从业者也可能会参与到问答中，提供专业的解答和分析，提高问答的质量和权威性。
 * 我的（登录和微信登录）：
 * 登录功能：用户可以通过账号密码登录或微信登录的方式进入
 * “我的” 页面。登录后，系统可以记录用户的个人信息、浏览历史、收藏、点赞、评论等数据，方便用户随时查看和管理自己在热点新闻平台上的活动记录。
 * 个性化设置：在该页面中，用户可以根据自己的兴趣和需求进行个性化设置，比如设置新闻推送的频率、类型、时间段等，
 * 以便获取更符合自己需求的热点新闻资讯。此外，用户还可以修改个人资料、绑定或解绑第三方账号等。
 */
class LotteryView @JvmOverloads constructor(
    context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {

    private val blockSize = 0.3f // 每个格子占整个 View 的比例
    private val lineWidth = 5f // 格子线的宽度
    private val textSize = 18
    private val prizeList = listOf(
        "15金币",
        "下次再来",
        "15金币",
        "下次再来",
        "15金币",
        "下次再来",
        "15金币",
        "下次再来",
        "15金币"
    )


    private val prizeIndexList = listOf<Int>(0, 1, 2, 5, 8, 7, 6, 3, 4)
    private val prizeIndexList2 = mutableListOf<Int>()

    // 定义每个奖品的概率，这里只是简单示例，可以根据实际需求调整
    private val prizeProbabilities = listOf(0.15, 0.15, 0.2, 0.1, 0.1, 0.1, 0.1, 0.05, 0.05)
    private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
    private var isRunning = false
    private var currentIndex = -1
    private var currentPos = -1
    private var animator: ValueAnimator? = null
    private var centerButtonRadius = resources.getDimension(R.dimen.button_size) / 2f
    private var centerButtonX = 0f
    private var centerButtonY = 0f
    private var gridSize = resources.getDimension(R.dimen.lottery_grid_size)
    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)
        centerButtonX = w / 2f
        centerButtonY = h / 2f
    }

    private lateinit var startButtonImage: Bitmap

    init {
        startButtonImage = BitmapFactory.decodeResource(resources, R.mipmap.cj)
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)

        val width = width.toFloat()
        val height = height.toFloat()

        // 绘制格子和文字及图标
//        for (i in 0 until 3) {
//            for (j in 0 until 3) {
//                val left = (width - gridSize) / 2 + j * gridSize * blockSize
//                val top = (height - gridSize) / 2 + i * gridSize * blockSize
//                val right = left + gridSize * blockSize
//                val bottom = top + gridSize * blockSize
//
        // 绘制图标和文字
        for (i in 0 until 3) {
            for (j in 0 until 3) {
                val left = (width - gridSize) / 2 + j * gridSize * blockSize
                val top = (height - gridSize) / 2 + i * gridSize * blockSize
                val right = left + gridSize * blockSize
                val bottom = top + gridSize * blockSize

                // 根据奖品索引获取对应的图标资源 ID
                val iconResId = when (i * 3 + j) {
                    0 -> R.mipmap.swjb
                    1 -> R.mipmap.xczl
                    2 -> R.mipmap.swjb
                    3 -> R.mipmap.xczl
                    4 -> R.mipmap.xczl
                    5 -> R.mipmap.xczl
                    6 -> R.mipmap.swjb
                    7 -> R.mipmap.xczl
                    8 -> R.mipmap.swjb
                    else -> R.mipmap.ic_launcher // 如果索引不匹配，提供一个默认图标
                }

                // 绘制图标
                val iconBitmap = BitmapFactory.decodeResource(resources, iconResId)
                val iconWidth = iconBitmap.width
                val iconHeight = iconBitmap.height
                // 放大图标尺寸
                val scaleFactor = 0.5f // 这里可以根据需要调整放大倍数
                val newIconWidth = (iconWidth * scaleFactor).toInt()
                val newIconHeight = (iconHeight * scaleFactor).toInt()
                // 重新计算绘制位置
                val iconLeft = left + (gridSize * blockSize - newIconWidth) / 2
                val iconTop = top + (gridSize * blockSize - newIconHeight) / 2
                canvas.drawBitmap(iconBitmap, iconLeft, iconTop, null)

            }
        }

        // 绘制中间按钮
        paint.style = Paint.Style.FILL
        canvas.drawCircle(centerButtonX, centerButtonY, centerButtonRadius, paint)
        val buttonImageWidth = startButtonImage.width
        val buttonImageHeight = startButtonImage.height
        val buttonImageLeft = centerButtonX - buttonImageWidth / 2f
        val buttonImageTop = centerButtonY - buttonImageHeight / 2f
        canvas.drawBitmap(startButtonImage, buttonImageLeft, buttonImageTop, null)
        // 如果动画正在运行，绘制选中框和箭头（不绘制中间格子的选中效果）
        if (isRunning && currentIndex != 4) {
            val left = (width - gridSize) / 2 + (currentIndex % 3) * gridSize * blockSize
            val top = (height - gridSize) / 2 + (currentIndex / 3) * gridSize * blockSize
            val right = left + gridSize * blockSize
            val bottom = top + gridSize * blockSize

            // 保存原始背景颜色
            val originalColor = paint.color
            // 设置为灰色
            paint.color = Color.GRAY
            paint.style = Paint.Style.FILL
            canvas.drawRect(left, top, right, bottom, paint)
            // 恢复原始背景颜色
            paint.color = originalColor

            // 绘制格子边框（可选，如果需要保留边框的话）
            paint.style = Paint.Style.STROKE
            paint.color = Color.LTGRAY
            paint.strokeWidth = lineWidth
            canvas.drawRect(left, top, right, bottom, paint)
        }
    }

    override fun onTouchEvent(event: MotionEvent): Boolean {
        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                val dx = event.x - centerButtonX
                val dy = event.y - centerButtonY
                if (sqrt(dx.pow(2) + dy.pow(2)) <= centerButtonRadius) {
                    startLottery()
                    return true
                }
            }
        }
        return super.onTouchEvent(event)
    }

    fun startLottery() {
        isRunning = true
        //每次开始先清空prizeIndexList2
        prizeIndexList2.clear()
        prizeIndexList2.addAll(prizeIndexList)
        //通过动态随机添加prizeIndexList2 数量，来实现动画结束位置的随性值
        prizeIndexList2.addAll(prizeIndexList.subList(0, kotlin.random.Random.nextInt(1, 8)))
        animator = ValueAnimator.ofInt(0, prizeIndexList2.size - 1).apply {
            interpolator = LinearInterpolator()
            repeatMode = ValueAnimator.RESTART
            repeatCount = 3

            addUpdateListener { animation ->
                val value = animation.animatedValue as Int
//                Log.d("LotteryView value", value.toString())
                if (currentPos != value) {
                    currentPos = value
                    currentIndex = prizeIndexList2.get(currentPos)
                    invalidate()
                    Log.d("LotteryView currentIndex", currentIndex.toString())
                }


            }
            start()
        }
    }

    fun stopLottery() {
        animator?.removeAllUpdateListeners()
        animator?.end()
        isRunning = false

        // 根据概率选择奖品
        val randomValue = kotlin.random.Random.nextDouble()
        var cumulativeProbability = 0.0
        var finalIndex = 0
        for ((index, probability) in prizeProbabilities.withIndex()) {
            cumulativeProbability += probability
            if (randomValue <= cumulativeProbability) {
                finalIndex = index
                break
            }
        }
        currentIndex = finalIndex
        invalidate()
    }

    fun getCurrentPrize(): String {
        return prizeList[currentIndex]
    }
}